home *** CD-ROM | disk | FTP | other *** search
/ OpenGL Superbible (2nd Edition) / OpenGL SuperBible e2.iso / tools / GLUT-3.7 / LIB / GLUT / win32_glx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-12  |  6.7 KB  |  256 lines
  1.  
  2. /* Copyright (c) Nate Robins, 1997. */
  3.  
  4. /* This program is freely distributable without licensing fees 
  5.    and is provided without guarantee or warrantee expressed or 
  6.    implied. This program is -not- in the public domain. */
  7.  
  8. #include <stdio.h>
  9. #include "win32_glx.h"
  10.  
  11. /* global current HDC */
  12. extern HDC XHDC;
  13.  
  14. GLXContext
  15. glXCreateContext(Display * display, XVisualInfo * visinfo,
  16.   GLXContext share, Bool direct)
  17. {
  18.   /* KLUDGE: GLX really expects a display pointer to be passed
  19.      in as the first parameter, but Win32 needs an HDC instead,
  20.      so BE SURE that the global XHDC is set before calling this
  21.      routine. */
  22.   HGLRC context;
  23.  
  24.   context = wglCreateContext(XHDC);
  25.  
  26. #if 0
  27.   /* XXX GLUT doesn't support it now, so don't worry about display list
  28.      and texture object sharing. */
  29.   if (share) {
  30.     wglShareLists(share, context);
  31.   }
  32. #endif
  33.  
  34.   /* Since direct rendering is implicit, the direct flag is
  35.      ignored. */
  36.  
  37.   return context;
  38. }
  39.  
  40. int
  41. glXGetConfig(Display * display, XVisualInfo * visual, int attrib, int *value)
  42. {
  43.   if (!visual)
  44.     return GLX_BAD_VISUAL;
  45.  
  46.   switch (attrib) {
  47.   case GLX_USE_GL:
  48.     if (visual->dwFlags & (PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW)) {
  49.       /* XXX Brad's Matrix Millenium II has problems creating
  50.          color index windows in 24-bit mode (lead to GDI crash)
  51.          and 32-bit mode (lead to black window).  The cColorBits
  52.          filed of the PIXELFORMATDESCRIPTOR returned claims to
  53.          have 24 and 32 bits respectively of color indices. 2^24
  54.          and 2^32 are ridiculously huge writable colormaps.
  55.          Assume that if we get back a color index
  56.          PIXELFORMATDESCRIPTOR with 24 or more bits, the
  57.          PIXELFORMATDESCRIPTOR doesn't really work and skip it.
  58.          -mjk */
  59.       if (visual->iPixelType == PFD_TYPE_COLORINDEX
  60.         && visual->cColorBits >= 24) {
  61.         *value = 0;
  62.       } else {
  63.     *value = 1;
  64.       }
  65.     } else {
  66.       *value = 0;
  67.     }
  68.     break;
  69.   case GLX_BUFFER_SIZE:
  70.     /* KLUDGE: if we're RGBA, return the number of bits/pixel,
  71.        otherwise, return 8 (we guessed at 256 colors in CI
  72.        mode). */
  73.     if (visual->iPixelType == PFD_TYPE_RGBA)
  74.       *value = visual->cColorBits;
  75.     else
  76.       *value = 8;
  77.     break;
  78.   case GLX_LEVEL:
  79.     /* The bReserved flag of the pfd contains the
  80.        overlay/underlay info. */
  81.     *value = visual->bReserved;
  82.     break;
  83.   case GLX_RGBA:
  84.     *value = visual->iPixelType == PFD_TYPE_RGBA;
  85.     break;
  86.   case GLX_DOUBLEBUFFER:
  87.     *value = visual->dwFlags & PFD_DOUBLEBUFFER;
  88.     break;
  89.   case GLX_STEREO:
  90.     *value = visual->dwFlags & PFD_STEREO;
  91.     break;
  92.   case GLX_AUX_BUFFERS:
  93.     *value = visual->cAuxBuffers;
  94.     break;
  95.   case GLX_RED_SIZE:
  96.     *value = visual->cRedBits;
  97.     break;
  98.   case GLX_GREEN_SIZE:
  99.     *value = visual->cGreenBits;
  100.     break;
  101.   case GLX_BLUE_SIZE:
  102.     *value = visual->cBlueBits;
  103.     break;
  104.   case GLX_ALPHA_SIZE:
  105.     *value = visual->cAlphaBits;
  106.     break;
  107.   case GLX_DEPTH_SIZE:
  108.     *value = visual->cDepthBits;
  109.     break;
  110.   case GLX_STENCIL_SIZE:
  111.     *value = visual->cStencilBits;
  112.     break;
  113.   case GLX_ACCUM_RED_SIZE:
  114.     *value = visual->cAccumRedBits;
  115.     break;
  116.   case GLX_ACCUM_GREEN_SIZE:
  117.     *value = visual->cAccumGreenBits;
  118.     break;
  119.   case GLX_ACCUM_BLUE_SIZE:
  120.     *value = visual->cAccumBlueBits;
  121.     break;
  122.   case GLX_ACCUM_ALPHA_SIZE:
  123.     *value = visual->cAccumAlphaBits;
  124.     break;
  125.   default:
  126.     return GLX_BAD_ATTRIB;
  127.   }
  128.   return 0;
  129. }
  130.  
  131. XVisualInfo *
  132. glXChooseVisual(Display * display, int screen, int *attribList)
  133. {
  134.   /* KLUDGE: since we need the HDC, MAKE SURE to set XHDC
  135.      before calling this routine. */
  136.  
  137.   int *p = attribList;
  138.   int pf;
  139.   PIXELFORMATDESCRIPTOR pfd;
  140.   PIXELFORMATDESCRIPTOR *match = NULL;
  141.   int stereo = 0;
  142.  
  143.   /* Avoid seg-faults. */
  144.   if (!p)
  145.     return NULL;
  146.  
  147.   memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
  148.   pfd.nSize = (sizeof(PIXELFORMATDESCRIPTOR));
  149.   pfd.nVersion = 1;
  150.  
  151.   /* Defaults. */
  152.   pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
  153.   pfd.iPixelType = PFD_TYPE_COLORINDEX;
  154.   pfd.cColorBits = 32;
  155.   pfd.cDepthBits = 0;
  156.  
  157.   while (*p) {
  158.     switch (*p) {
  159.     case GLX_USE_GL:
  160.       pfd.dwFlags |= PFD_SUPPORT_OPENGL;
  161.       break;
  162.     case GLX_BUFFER_SIZE:
  163.       pfd.cColorBits = *(++p);
  164.       break;
  165.     case GLX_LEVEL:
  166.       /* the bReserved flag of the pfd contains the
  167.          overlay/underlay info. */
  168.       pfd.bReserved = *(++p);
  169.       break;
  170.     case GLX_RGBA:
  171.       pfd.iPixelType = PFD_TYPE_RGBA;
  172.       break;
  173.     case GLX_DOUBLEBUFFER:
  174.       pfd.dwFlags |= PFD_DOUBLEBUFFER;
  175.       break;
  176.     case GLX_STEREO:
  177.       stereo = 1;
  178.       pfd.dwFlags |= PFD_STEREO;
  179.       break;
  180.     case GLX_AUX_BUFFERS:
  181.       pfd.cAuxBuffers = *(++p);
  182.       break;
  183.     case GLX_RED_SIZE:
  184.       pfd.cRedBits = 8; /* Try to get the maximum. */
  185.       ++p;
  186.       break;
  187.     case GLX_GREEN_SIZE:
  188.       pfd.cGreenBits = 8;
  189.       ++p;
  190.       break;
  191.     case GLX_BLUE_SIZE:
  192.       pfd.cBlueBits = 8;
  193.       ++p;
  194.       break;
  195.     case GLX_ALPHA_SIZE:
  196.       pfd.cAlphaBits = 8;
  197.       ++p;
  198.       break;
  199.     case GLX_DEPTH_SIZE:
  200.       pfd.cDepthBits = 32;
  201.       ++p;
  202.       break;
  203.     case GLX_STENCIL_SIZE:
  204.       pfd.cStencilBits = *(++p);
  205.       break;
  206.     case GLX_ACCUM_RED_SIZE:
  207.     case GLX_ACCUM_GREEN_SIZE:
  208.     case GLX_ACCUM_BLUE_SIZE:
  209.     case GLX_ACCUM_ALPHA_SIZE:
  210.       /* I believe that WGL only used the cAccumRedBits,
  211.      cAccumBlueBits, cAccumGreenBits, and cAccumAlphaBits fields
  212.      when returning info about the accumulation buffer precision.
  213.      Only cAccumBits is used for requesting an accumulation
  214.      buffer. */
  215.       pfd.cAccumBits = 1;
  216.       ++p;
  217.       break;
  218.     }
  219.     ++p;
  220.   }
  221.  
  222.   /* Let Win32 choose one for us. */
  223.   pf = ChoosePixelFormat(XHDC, &pfd);
  224.   if (pf > 0) {
  225.     match = (PIXELFORMATDESCRIPTOR *) malloc(sizeof(PIXELFORMATDESCRIPTOR));
  226.     DescribePixelFormat(XHDC, pf, sizeof(PIXELFORMATDESCRIPTOR), match);
  227.  
  228.     /* ChoosePixelFormat is dumb in that it will return a pixel
  229.        format that doesn't have stereo even if it was requested
  230.        so we need to make sure that if stereo was selected, we
  231.        got it. */
  232.     if (stereo) {
  233.       if (!(match->dwFlags & PFD_STEREO)) {
  234.         free(match);
  235.     return NULL;
  236.       }
  237.     }
  238.     /* XXX Brad's Matrix Millenium II has problems creating
  239.        color index windows in 24-bit mode (lead to GDI crash)
  240.        and 32-bit mode (lead to black window).  The cColorBits
  241.        filed of the PIXELFORMATDESCRIPTOR returned claims to
  242.        have 24 and 32 bits respectively of color indices. 2^24
  243.        and 2^32 are ridiculously huge writable colormaps.
  244.        Assume that if we get back a color index
  245.        PIXELFORMATDESCRIPTOR with 24 or more bits, the
  246.        PIXELFORMATDESCRIPTOR doesn't really work and skip it.
  247.        -mjk */
  248.     if (match->iPixelType == PFD_TYPE_COLORINDEX
  249.       && match->cColorBits >= 24) {
  250.       free(match);
  251.       return NULL;
  252.     }
  253.   }
  254.   return match;
  255. }
  256.